from typing import Dict, List, Any, Optional, Union
# from .redis_client import RedisClient
from Agent.utils.redis_client import RedisClient


class AnomalyDataManager:
    """
    异常数据管理器类，用于处理来自Redis的异常数据。
    提供高级函数来处理和分析异常数据。
    """

    def __init__(self, redis_host='localhost', redis_port=6379, redis_db=0, redis_password=None):
        """
        使用Redis连接参数初始化异常数据管理器。

        参数:
            redis_host (str): Redis主机地址
            redis_port (int): Redis端口
            redis_db (int): Redis数据库编号
            redis_password (str, optional): Redis密码
        """
        self.redis_client = RedisClient(
            host=redis_host,
            port=redis_port,
            db=redis_db,
            password=redis_password
        )

    def get_all_anomaly_data(self, key: str) -> Dict[str, Any]:
        """
        获取完整的异常数据，包括异常列表和分析请求。

        参数:
            key (str): Redis键

        返回:
            Dict: 完整的异常数据，如果未找到则返回空字典
        """
        data = self.redis_client.get_json_data(key)
        if not data:
            return {}
        return data

    def list_all_anomalies(self, key: str) -> List[Dict[str, Any]]:
        """
        以列表形式返回所有异常数据。

        参数:
            key (str): Redis键

        返回:
            List[Dict[str, Any]]: 所有异常对象的列表，如果未找到则返回空列表
        """
        return self.redis_client.get_anomalies(key)

    def get_critical_anomalies(self, key: str) -> List[Dict[str, Any]]:
        """
        获取所有严重级别的异常。

        参数:
            key (str): Redis键

        返回:
            List: 严重级别异常列表
        """
        return self.redis_client.get_anomalies_by_severity(key, "critical")

    def get_alert_anomalies(self, key: str) -> List[Dict[str, Any]]:
        """
        获取所有警报级别的异常。

        参数:
            key (str): Redis键

        返回:
            List: 警报级别异常列表
        """
        return self.redis_client.get_anomalies_by_severity(key, "alert")

    def get_warning_anomalies(self, key: str) -> List[Dict[str, Any]]:
        """
        获取所有警告级别的异常。

        参数:
            key (str): Redis键

        返回:
            List: 警告级别异常列表
        """
        return self.redis_client.get_anomalies_by_severity(key, "warning")

    def get_high_impact_anomalies(self, key: str) -> List[Dict[str, Any]]:
        """
        获取所有高业务影响的异常。

        参数:
            key (str): Redis键

        返回:
            List: 高业务影响异常列表
        """
        return self.redis_client.get_anomalies_with_impact(key, "high")

    def get_anomalies_for_service_group(self, key: str, services: List[str]) -> List[Dict[str, Any]]:
        """
        获取影响指定服务组的异常。

        参数:
            key (str): Redis键
            services (List[str]): 服务名称列表

        返回:
            List: 影响任一指定服务的异常列表
        """
        anomalies = self.redis_client.get_anomalies(key)
        result = []
        for anomaly in anomalies:
            affected = anomaly.get('affected_services', [])
            if any(service in affected for service in services):
                result.append(anomaly)
        return result

    def get_anomalies_by_complexity(self, key: str, min_complexity: int = 0) -> List[Dict[str, Any]]:
        """
        获取复杂度分数高于指定最小值的异常。

        参数:
            key (str): Redis键
            min_complexity (int): 最小复杂度分数

        返回:
            List: 复杂度高于阈值的异常列表
        """
        anomalies = self.redis_client.get_anomalies(key)
        return [a for a in anomalies if a.get('complexity_score', 0) >= min_complexity]

    def get_recent_anomalies(self, key: str, max_count: int = 10) -> List[Dict[str, Any]]:
        """
        获取最近的异常，数量不超过max_count。

        参数:
            key (str): Redis键
            max_count (int): 返回的最大异常数量

        返回:
            List: 最近异常列表
        """
        anomalies = self.redis_client.get_anomalies(key)
        # 按开始时间降序排序（最近的排在前面）
        sorted_anomalies = sorted(
            anomalies,
            key=lambda x: x.get('start_time', ''),
            reverse=True
        )
        return sorted_anomalies[:max_count]

    def get_anomaly_summary(self, key: str) -> Dict[str, Any]:
        """
        获取按类型和严重程度统计的异常摘要。

        参数:
            key (str): Redis键

        返回:
            Dict: 异常摘要
        """
        anomalies = self.redis_client.get_anomalies(key)

        # 按类型计数
        types = {}
        for anomaly in anomalies:
            anomaly_type = anomaly.get('type')
            if anomaly_type:
                types[anomaly_type] = types.get(anomaly_type, 0) + 1

        # 按严重程度计数
        severities = {}
        for anomaly in anomalies:
            severity = anomaly.get('severity')
            if severity:
                severities[severity] = severities.get(severity, 0) + 1

        # 按设备计数
        devices = {}
        for anomaly in anomalies:
            device = anomaly.get('device')
            if device:
                devices[device] = devices.get(device, 0) + 1

        return {
            'total': len(anomalies),
            'by_type': types,
            'by_severity': severities,
            'by_device': devices
        }

    def get_analysis_info(self, key: str) -> Dict[str, Any]:
        """
        获取分析请求信息。

        参数:
            key (str): Redis键

        返回:
            Dict: 分析请求信息，如果未找到则返回空字典
        """
        analysis = self.redis_client.get_analysis_request(key)
        return analysis or {}


# 使用示例
if __name__ == "__main__":
    # 创建异常数据管理器实例
    manager = AnomalyDataManager(redis_host='localhost', redis_port=6379)

    # 存储异常数据的Redis键
    redis_key = "anomaly_data"

    # 获取所有异常数据
    all_data = manager.get_all_anomaly_data(redis_key)
    print(f"异常总数: {len(all_data.get('anomalies', []))}")

    # 获取所有异常列表
    all_anomalies = manager.list_all_anomalies(redis_key)
    print(f"异常列表长度: {len(all_anomalies)}")
    print(f"第一个异常ID: {all_anomalies[0]['id'] if all_anomalies else '无异常'}")

    # 详细演示list_all_anomalies方法的使用
    print("\n===== 异常列表详细信息 =====")
    anomalies = manager.list_all_anomalies(redis_key)
    for i, anomaly in enumerate(anomalies):
        print(f"\n--- 异常 #{i+1} ---")
        print(f"ID: {anomaly.get('id')}")
        print(f"类型: {anomaly.get('type')}")
        print(f"测量项: {anomaly.get('measurement')}")
        print(f"严重程度: {anomaly.get('severity')}")
        print(f"设备: {anomaly.get('device')}")
        print(f"开始时间: {anomaly.get('start_time')}")
        print(f"持续时间: {anomaly.get('duration')}秒")
        print(f"复杂度: {anomaly.get('complexity_score')}")
        print(f"业务影响: {anomaly.get('business_impact')}")
        print(f"受影响服务: {', '.join(anomaly.get('affected_services', []))}")

        # 输出指标数据
        metrics = anomaly.get('metrics', {})
        print("指标数据:")
        for metric_name, metric_value in metrics.items():
            print(f"  - {metric_name}: {metric_value}")

        # 输出日志信息（仅显示前2条）
        logs = anomaly.get('logs', [])
        if logs:
            print("相关日志 (前2条):")
            for log in logs[:2]:
                print(f"  - {log}")

    print("\n===== 使用示例：过滤CPU相关异常 =====")
    cpu_anomalies = [a for a in anomalies if a.get('type') == 'cpu']
    print(f"CPU异常数量: {len(cpu_anomalies)}")

    print("\n===== 使用示例：按照复杂度排序异常 =====")
    sorted_by_complexity = sorted(anomalies, key=lambda x: x.get('complexity_score', 0), reverse=True)
    print("复杂度前3名的异常:")
    for i, anomaly in enumerate(sorted_by_complexity[:3]):
        print(f"{i+1}. ID: {anomaly.get('id')} - 复杂度: {anomaly.get('complexity_score')} - 类型: {anomaly.get('type')}")

    # 获取严重级别异常
    critical = manager.get_critical_anomalies(redis_key)
    print(f"\n严重级别异常: {len(critical)}")

    # 获取高影响异常
    high_impact = manager.get_high_impact_anomalies(redis_key)
    print(f"高业务影响异常: {len(high_impact)}")

    # 获取特定服务的异常
    web_api_anomalies = manager.get_anomalies_for_service_group(redis_key, ["web", "api"])
    print(f"Web/API异常: {len(web_api_anomalies)}")

    # 获取复杂异常（复杂度分数 >= 10）
    complex_anomalies = manager.get_anomalies_by_complexity(redis_key, 10)
    print(f"复杂异常: {len(complex_anomalies)}")

    # 获取摘要
    summary = manager.get_anomaly_summary(redis_key)
    print(f"异常摘要: {summary}")

    # 获取分析请求信息
    analysis = manager.get_analysis_info(redis_key)
    print(f"分析请求优先级: {analysis.get('priority', '未知')}")

    print("\n===== 获取所有异常数据 =====")
    print("所有异常数据:")
    print(all_data )